from django.contrib.auth import logout
from django.contrib.sites import requests
from django.shortcuts import render
from rest_framework import status
from rest_framework.response import Response
from rest_framework.utils import json
from rest_framework.views import APIView
from .models import *
from .serializers import *


# Create your views here.
class RoleView(APIView):
    """
    角色管理视图，提供获取所有角色和创建新角色的接口。
    """

    def get(self, request):
        """
        获取所有角色信息。

        返回所有角色的序列化数据。
        """
        roles = Roles.objects.all()
        print(roles)
        serializer = RolesSerializer(roles, many=True)
        print(serializer.data)
        return Response(serializer.data)

    def post(self, request):
        """
        创建新角色。

        接收客户端发送的角色数据，验证后创建新角色。
        """
        serializer = RolesSerializer(data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.errors, status=status.HTTP_201_CREATED)
        return Response(serializer.data, status=status.HTTP_400_BAD_REQUEST)


class ResourceView(APIView):
    """
    资源管理视图，提供获取所有资源和创建新资源的接口。
    """

    def get(self, request):
        """
        获取所有资源信息。

        返回所有资源的序列化数据。
        """
        # 获取参数
        roleid = request.GET.get('roleid')
        # 获取所有资源列表
        res = Resource.objects.all()
        rlist = [{"key": i.id, "label": i.name} for i in res]
        resser = ResourceSerializer(res, many=True)
        # 序列化器处理
        # 获取此角色对应的资源列表
        roles = Roles.objects.filter(id=roleid).first()
        rres = roles.resource.all()
        # 选中的列表
        idslist = []
        if rres:
            for i in rres:
                idslist.append(i.id)
        # 返回数据
        return Response({"code": 200, "reslist": rlist, "checklist": idslist})

    def post(self, request):
        """
        创建新资源。

        接收客户端发送的资源数据，验证后创建新资源。
        """
        # 获取参数
        roleid = request.data.get('roleid')
        resid = request.data.get('checkedids')
        resdata = request.data
        print(111111111111, resdata)
        if resid is None:
            resid = []
        print('###################', resid, roleid)

        # 查询角色
        roles = Roles.objects.filter(id=roleid)
        for role in roles:
            # 删除此角色下所有资源
            role.resource.clear()
            # 添加资源列表
            role.resource.add(*resid)

        # 返回响应
        return Response({'code': 200})


class RoleResourceView(APIView):
    """
    角色资源管理视图，提供获取所有角色资源关系和创建新角色资源关系的接口。
    """

    def get(self, request):
        """
        获取所有角色资源关系信息。

        返回所有角色资源关系的序列化数据。
        """

        # 获取参数
        roleid = request.GET.get('roleid')
        # 获取所有资源列表
        res = Resource.objects.all()
        rlist = [{"key": i.id, "label": i.name} for i in res]
        resser = ResourceSerializer(res, many=True)
        # 序列化器处理
        # 获取此角色对应的资源列表
        roles = Roles.objects.filter(id=roleid).first()
        rres = roles.resource.all()
        # 选中的列表
        idslist = []
        if rres:
            for i in rres:
                idslist.append(i.id)
        # 返回数据
        return Response({"code": 200, "reslist": rlist, "checklist": idslist})

    def post(self, request):
        """
        创建新的角色资源关系。

        接收客户端发送的角色资源关系数据，验证后创建新的关系。
        """
        # 获取参数
        roleid = request.data.get('roleid')
        resid = request.data.get('resid')
        print('###################', resid, roleid)
        # 查询角色
        roles = Roles.objects.filter(id=roleid).first()
        # 删除此角色下所有资源
        roles.resource.clear()
        roles.resource.add(*resid)
        # 添加资源列表
        return Response({'code': 200})


class UserView(APIView):
    """
    用户管理视图，提供获取所有用户和创建新用户的接口。
    """

    def get(self, request):
        """
        获取所有用户信息。

        返回所有用户的序列化数据。
        """
        users = User.objects.all()
        serializer = UserSerializer(users, many=True)
        return Response(serializer.data)

    def post(self, request):
        """
        创建新用户。

        接收客户端发送的用户数据，验证后创建新用户。
        """
        serializer = UserSerializer(data=request.data)
        if serializer.is_valid():
            # 对密码进行加密处理
            serializer.validated_data['password'] = make_password(serializer.validated_data['password'])
            # 保存新用户
            serializer.save()
            return Response(serializer.data, status=status.HTTP_201_CREATED)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)


class UserRoleView(APIView):
    """
    用户角色管理视图，提供获取所有用户角色关系和创建新用户角色关系的接口。
    """

    def get(self, request):
        """
        获取所有用户角色关系信息。

        返回所有用户角色关系的序列化数据。
        """
        users = User.objects.all()
        serializer = UserSerializer(users, many=True)
        return Response(serializer.data)

    def post(self, request):
        """
        创建新的用户角色关系。

        接收客户端发送的用户角色关系数据，验证后创建新的关系。
        """
        serializer = UserRoleSerializer(data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data, status=status.HTTP_201_CREATED)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)


class UserResourceView(APIView):
    """
    用户资源管理视图，提供获取所有用户资源关系和创建新用户资源关系的接口。
    """

    def get(self, request):
        """
        获取所有用户资源关系信息。

        返回所有用户资源关系的序列化数据。
        """
        users = User.objects.all()
        serializer = UserSerializer(users, many=True)
        return Response(serializer.data)

    def post(self, request):
        """
        创建新的用户资源关系。

        接收客户端发送的用户资源关系数据，验证后创建新的关系。
        """
        serializer = UserSerializer(data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data, status=status.HTTP_201_CREATED)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)


from django.contrib.auth.hashers import make_password


class LoginView(APIView):
    """
    用户登录视图，提供用户登录验证的接口。
    """

    def post(self, request):
        """
        用户登录验证。

        接收客户端发送的手机号和密码，验证后返回用户信息。
        """
        username = request.data.get('username')
        mobile = request.data.get('mobile')
        password = request.data.get('password')
        user = User.objects.filter(username=username, password=password, mobile=mobile).first()
        if user and user.password == make_password(password):
            serializer = UserSerializer(user)
            return Response(serializer.data)
        return Response({'error': 'Invalid credentials'}, status=status.HTTP_401_UNAUTHORIZED)

    def get(self, request):
        """
        获取所有用户信息。

        用于展示所有用户数据，通常不被使用，因为用户登录验证使用POST方法。
        """
        users = User.objects.all()
        serializer = UserSerializer(users, many=True)
        return Response(serializer.data)

    def post_save_user(self, request):
        """
        保存用户信息到数据库
        此方法在用户登录验证成功后被调用
        :param request:
        :return:
        """
        username = request.data.get('username')
        mobile = request.data.get('mobile')
        password = request.data.get('password')
        # 创建新的用户实例
        new_user = User(username=username, mobile=mobile, password=make_password(password))
        # 保存到数据库
        new_user.save()
        # 返回成功响应
        return Response({'message': '用户创建成功！'}, status=status.HTTP_201_CREATED)


class LogoutView(APIView):
    """
    用户登出视图，提供用户登出验证的接口。
    """

    def post(self, request):
        """
        用户登出。

        登出用户，清除session和相关认证信息。
        """
        logout(request)
        return Response(status=status.HTTP_204_NO_CONTENT)

    def get(self, request):
        """
        获取所有用户信息。

        与LoginView的GET方法相同，主要为了展示所有用户数据。
        """
        users = User.objects.all()
        serializer = UserSerializer(users, many=True)
        return Response(serializer.data)


# 用户注册视图
class UserRegistrationView(APIView):
    def post(self, request):
        username = request.data.get('username')
        mobile = request.data.get('mobile')
        password = request.data.get('password')
        role_id = request.data.get('role')  # 获取角色ID

        if not username or not mobile or not password or not role_id:
            return Response({'error': '缺少必要的字段'}, status=400)

        try:
            role = Roles.objects.get(id=role_id)  # 获取角色对象
            user = User.objects.create(
                username=username,
                mobile=mobile,
                password=make_password(password),
                role=role  # 关联角色
            )
            user.save()
            return Response({'message': '用户创建成功'}, status=201)
        except Exception as e:
            return Response({'error': str(e)}, status=500)


# 项目视图
class ProjectView(APIView):
    def post(self, request):
        """
        创建项目视图
        :param request:
        :return:
        """
        data = request.data
        print(data)
        serializer = ProjectSerializer(data=data)
        if serializer.is_valid():
            serializer.save()
            return Response({"code": 200, "serializer": serializer.data})
        return Response({"code": 10010, "serializer": serializer.errors})

    def get(self, request):
        """
        获取项目视图
        :param request:
        :return:
        """
        pro = Project.objects.all()
        ser = ProjectSerializer(pro, many=True)
        return Response({"code": 200, 'msg': '查询成功', 'data': ser.data})


class TaskView(APIView):
    def post(self, request):
        """
        创建任务视图
        :param request:
        :return:
        """
        data = request.data
        print(data)
        serializer = TaskSerializer(data=data)
        if serializer.is_valid():
            serializer.save()
            print("serializer.data", serializer.data)
            return Response({"code": 200, 'msg': '分配成功', "serializer": serializer.data})
        return Response({"code": 10010, 'msg': serializer.errors})

    def get(self, request):
        """
        获取任务视图
        :param request:
        :return:
        """
        pro = Task.objects.all()
        ser = TaskSerializer(pro, many=True)
        return Response({"code": 200, 'msg': '查询成功', 'data': ser.data})


from protwo import settings
import os
import pandas as pd


class ReadCsv(APIView):
    def post(self, request):
        # 获取文件
        file = request.FILES['file']

        # # 生成文件路径
        file_path = os.path.join(settings.MEDIA_ROOT, file.name)
        with open(file_path, 'wb+') as destination:
            for chunk in file.chunks():
                destination.write(chunk)
                # filepath = "/Users/hanxiaobai/Downloads/dxb/2310a/education/static/upload/1.csv"
        df = pd.read_excel(file_path)

        # 选取flag为True的行
        # filtered_df = df[df['flag']]  # 或者 df[df['flag'] == True]，但直接df[df['flag']]更简洁

        # # 根据date列分组
        # grouped_df = filtered_df.groupby('date')

        # 现在你可以对grouped_df进行进一步的操作，比如计算每个分组的行数等
        for name, group in df.iterrows():
            print(f"Date: {name}, Rows: {len(group)}")
            # 写入测试表
            TestCase.objects.create(taskid=group['taskid_id'], url=group['url'], method=group['method'],
                                params=group['params'])
        testcase = TestCase.objects.all()
        return Response({"code": 200, 'cases': testcase})

    def get(self, request):
        case = TestCase.objects.filter(status=1).all()
        host = "http://127.0.0.1:9000/"
        for i in case:
            method = i.method
            if method == 'get':
                res = requests.get(host + str(i.url), params=json.loads(i.params))
            else:
                res = requests.post(host + str(i.url), data=json.loads(i.params))

            data = json.loads(res.text)
            if data['code'] == i.result_code:
                # 通过
                status = 2
                flag = True
            else:
                status = 3
                flag = False
            TestCase.objects.filter(id=i.id).update(status=status, result=json.dumps(data), flag=flag)
        return Response({"code": 200})


class TestListView(APIView):
    def get(self, request):
        test = TestCase.objects.all()
        ser = TestcaseSerializer(test, many=True)
        print(ser.data)
        return Response({"code": 200, 'list': ser.data})
